home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / lib / python2.4 / audiodev.pyc (.txt) < prev    next >
Python Compiled Bytecode  |  2005-10-18  |  8KB  |  301 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.4)
  3.  
  4. '''Classes for manipulating audio devices (currently only for Sun and SGI)'''
  5. __all__ = [
  6.     'error',
  7.     'AudioDev']
  8.  
  9. class error(Exception):
  10.     pass
  11.  
  12.  
  13. class Play_Audio_sgi:
  14.     classinited = 0
  15.     frameratelist = None
  16.     nchannelslist = None
  17.     sampwidthlist = None
  18.     
  19.     def initclass(self):
  20.         import AL as AL
  21.         self.frameratelist = [
  22.             (48000, AL.RATE_48000),
  23.             (44100, AL.RATE_44100),
  24.             (32000, AL.RATE_32000),
  25.             (22050, AL.RATE_22050),
  26.             (16000, AL.RATE_16000),
  27.             (11025, AL.RATE_11025),
  28.             (8000, AL.RATE_8000)]
  29.         self.nchannelslist = [
  30.             (1, AL.MONO),
  31.             (2, AL.STEREO),
  32.             (4, AL.QUADRO)]
  33.         self.sampwidthlist = [
  34.             (1, AL.SAMPLE_8),
  35.             (2, AL.SAMPLE_16),
  36.             (3, AL.SAMPLE_24)]
  37.         self.classinited = 1
  38.  
  39.     
  40.     def __init__(self):
  41.         import al as al
  42.         import AL
  43.         if not self.classinited:
  44.             self.initclass()
  45.         
  46.         self.oldparams = []
  47.         self.params = [
  48.             AL.OUTPUT_RATE,
  49.             0]
  50.         self.config = al.newconfig()
  51.         self.inited_outrate = 0
  52.         self.inited_width = 0
  53.         self.inited_nchannels = 0
  54.         self.converter = None
  55.         self.port = None
  56.  
  57.     
  58.     def __del__(self):
  59.         if self.port:
  60.             self.stop()
  61.         
  62.         if self.oldparams:
  63.             import al
  64.             import AL
  65.             al.setparams(AL.DEFAULT_DEVICE, self.oldparams)
  66.             self.oldparams = []
  67.         
  68.  
  69.     
  70.     def wait(self):
  71.         if not self.port:
  72.             return None
  73.         
  74.         import time as time
  75.         while self.port.getfilled() > 0:
  76.             time.sleep(0.10000000000000001)
  77.         self.stop()
  78.  
  79.     
  80.     def stop(self):
  81.         if self.port:
  82.             self.port.closeport()
  83.             self.port = None
  84.         
  85.         if self.oldparams:
  86.             import al
  87.             import AL
  88.             al.setparams(AL.DEFAULT_DEVICE, self.oldparams)
  89.             self.oldparams = []
  90.         
  91.  
  92.     
  93.     def setoutrate(self, rate):
  94.         for raw, cooked in self.frameratelist:
  95.             if rate == raw:
  96.                 self.params[1] = cooked
  97.                 self.inited_outrate = 1
  98.                 break
  99.                 continue
  100.         else:
  101.             raise error, 'bad output rate'
  102.  
  103.     
  104.     def setsampwidth(self, width):
  105.         for raw, cooked in self.sampwidthlist:
  106.             if width == raw:
  107.                 self.config.setwidth(cooked)
  108.                 self.inited_width = 1
  109.                 break
  110.                 continue
  111.         elif width == 0:
  112.             import AL
  113.             self.inited_width = 0
  114.             self.config.setwidth(AL.SAMPLE_16)
  115.             self.converter = self.ulaw2lin
  116.         else:
  117.             raise error, 'bad sample width'
  118.  
  119.     
  120.     def setnchannels(self, nchannels):
  121.         for raw, cooked in self.nchannelslist:
  122.             if nchannels == raw:
  123.                 self.config.setchannels(cooked)
  124.                 self.inited_nchannels = 1
  125.                 break
  126.                 continue
  127.         else:
  128.             raise error, 'bad # of channels'
  129.  
  130.     
  131.     def writeframes(self, data):
  132.         if not self.inited_outrate and self.inited_nchannels:
  133.             raise error, 'params not specified'
  134.         
  135.         if not self.port:
  136.             import al
  137.             import AL
  138.             self.port = al.openport('Python', 'w', self.config)
  139.             self.oldparams = self.params[:]
  140.             al.getparams(AL.DEFAULT_DEVICE, self.oldparams)
  141.             al.setparams(AL.DEFAULT_DEVICE, self.params)
  142.         
  143.         if self.converter:
  144.             data = self.converter(data)
  145.         
  146.         self.port.writesamps(data)
  147.  
  148.     
  149.     def getfilled(self):
  150.         if self.port:
  151.             return self.port.getfilled()
  152.         else:
  153.             return 0
  154.  
  155.     
  156.     def getfillable(self):
  157.         if self.port:
  158.             return self.port.getfillable()
  159.         else:
  160.             return self.config.getqueuesize()
  161.  
  162.     
  163.     def ulaw2lin(self, data):
  164.         import audioop as audioop
  165.         return audioop.ulaw2lin(data, 2)
  166.  
  167.  
  168.  
  169. class Play_Audio_sun:
  170.     
  171.     def __init__(self):
  172.         self.outrate = 0
  173.         self.sampwidth = 0
  174.         self.nchannels = 0
  175.         self.inited_outrate = 0
  176.         self.inited_width = 0
  177.         self.inited_nchannels = 0
  178.         self.converter = None
  179.         self.port = None
  180.  
  181.     
  182.     def __del__(self):
  183.         self.stop()
  184.  
  185.     
  186.     def setoutrate(self, rate):
  187.         self.outrate = rate
  188.         self.inited_outrate = 1
  189.  
  190.     
  191.     def setsampwidth(self, width):
  192.         self.sampwidth = width
  193.         self.inited_width = 1
  194.  
  195.     
  196.     def setnchannels(self, nchannels):
  197.         self.nchannels = nchannels
  198.         self.inited_nchannels = 1
  199.  
  200.     
  201.     def writeframes(self, data):
  202.         if not self.inited_outrate and self.inited_width and self.inited_nchannels:
  203.             raise error, 'params not specified'
  204.         
  205.         if not self.port:
  206.             import sunaudiodev as sunaudiodev
  207.             import SUNAUDIODEV as SUNAUDIODEV
  208.             self.port = sunaudiodev.open('w')
  209.             info = self.port.getinfo()
  210.             info.o_sample_rate = self.outrate
  211.             info.o_channels = self.nchannels
  212.             if self.sampwidth == 0:
  213.                 info.o_precision = 8
  214.                 self.o_encoding = SUNAUDIODEV.ENCODING_ULAW
  215.             else:
  216.                 info.o_precision = 8 * self.sampwidth
  217.                 info.o_encoding = SUNAUDIODEV.ENCODING_LINEAR
  218.                 self.port.setinfo(info)
  219.         
  220.         if self.converter:
  221.             data = self.converter(data)
  222.         
  223.         self.port.write(data)
  224.  
  225.     
  226.     def wait(self):
  227.         if not self.port:
  228.             return None
  229.         
  230.         self.port.drain()
  231.         self.stop()
  232.  
  233.     
  234.     def stop(self):
  235.         if self.port:
  236.             self.port.flush()
  237.             self.port.close()
  238.             self.port = None
  239.         
  240.  
  241.     
  242.     def getfilled(self):
  243.         if self.port:
  244.             return self.port.obufcount()
  245.         else:
  246.             return 0
  247.  
  248.  
  249.  
  250. def AudioDev():
  251.     
  252.     try:
  253.         import al
  254.     except ImportError:
  255.         
  256.         try:
  257.             import sunaudiodev
  258.             return Play_Audio_sun()
  259.         except ImportError:
  260.             
  261.             try:
  262.                 import Audio_mac as Audio_mac
  263.             except ImportError:
  264.                 raise error, 'no audio device'
  265.  
  266.             return Audio_mac.Play_Audio_mac()
  267.         except:
  268.             None<EXCEPTION MATCH>ImportError
  269.         
  270.  
  271.         None<EXCEPTION MATCH>ImportError
  272.  
  273.     return Play_Audio_sgi()
  274.  
  275.  
  276. def test(fn = None):
  277.     import sys as sys
  278.     if sys.argv[1:]:
  279.         fn = sys.argv[1]
  280.     else:
  281.         fn = 'f:just samples:just.aif'
  282.     import aifc as aifc
  283.     af = aifc.open(fn, 'r')
  284.     print fn, af.getparams()
  285.     p = AudioDev()
  286.     p.setoutrate(af.getframerate())
  287.     p.setsampwidth(af.getsampwidth())
  288.     p.setnchannels(af.getnchannels())
  289.     BUFSIZ = af.getframerate() / af.getsampwidth() / af.getnchannels()
  290.     while None:
  291.         data = af.readframes(BUFSIZ)
  292.         if not data:
  293.             break
  294.         
  295.         print len(data)
  296.     p.wait()
  297.  
  298. if __name__ == '__main__':
  299.     test()
  300.  
  301.